home *** CD-ROM | disk | FTP | other *** search
/ World of Video / World of Video.iso / gfxprograms / boards / retina / rblanke2.lha / RBlankers / main.c < prev    next >
C/C++ Source or Header  |  1994-07-12  |  9KB  |  412 lines
  1. #include <exec/memory.h>
  2. #include <exec/ports.h>
  3. #include <exec/execbase.h>
  4. #include <graphics/displayinfo.h>
  5. #include <intuition/intuitionbase.h>
  6. #include <intuition/gadgetclass.h>
  7. #include <libraries/commodities.h>
  8. #include <libraries/gadtools.h>
  9. #include <dos/dosextens.h>
  10. #include <dos/dostags.h>
  11. #include <utility/tagitem.h>
  12.  
  13. #include <clib/alib_protos.h>
  14. #include <clib/commodities_protos.h>
  15. #include <clib/dos_protos.h>
  16. #include <clib/exec_protos.h>
  17. #include <clib/gadtools_protos.h>
  18. #include <clib/graphics_protos.h>
  19. #include <clib/intuition_protos.h>
  20. #include <clib/macros.h>
  21. #include <clib/retina_protos.h>
  22. #include <libraries/retina.h>
  23.  
  24. #include <string.h>
  25. #include <math.h>
  26. #include <stdlib.h>
  27.  
  28. #include <pragmas/commodities_pragmas.h>
  29. #include <pragmas/dos_pragmas.h>
  30. #include <pragmas/exec_pragmas.h>
  31. #include <pragmas/gadtools_pragmas.h>
  32. #include <pragmas/graphics_pragmas.h>
  33. #include <pragmas/intuition_pragmas.h>
  34. #include <pragmas/retina_pragmas.h>
  35. #include "blanker.h"
  36.  
  37. extern UBYTE *VersionString;
  38.  
  39. void 
  40. chkabort(void)
  41. {
  42. }
  43.  
  44. /*
  45.  * Common Definitions
  46.  */
  47.  
  48. struct IntuitionBase *IntuitionBase;
  49. struct RetinaBase *RetinaBase;
  50. struct Library *CxBase, *GadToolsBase, *IconBase;
  51.  
  52. #define FINDPROCPORT (&((struct Process *)SysBase->ThisTask)->pr_MsgPort)
  53.  
  54. extern struct EasyStruct quitreq;
  55.  
  56. /*
  57.  * Reports an error using a requestor.
  58.  */
  59. void 
  60. Error(char *s)
  61. {
  62.     if (s) EasyRequest(NULL,&quitreq,NULL,s);
  63. }
  64.  
  65. /*
  66.  * Definitions for our Commodity
  67.  */
  68.  
  69. extern struct NewBroker NewBroker;
  70.  
  71. struct MsgPort *CxPort;
  72.  
  73. UBYTE *PopKey;
  74. UBYTE *BlankKey;
  75.  
  76.  
  77. LONG TimeOut, ClientTimeOut;
  78.  
  79. /*
  80.  * Definitions for Server/Client Communication
  81.  */
  82.  
  83. BYTE bsp_TimerSig, bsp_InputSig, bsp_ClientSig;
  84. struct Task *ServerProcess;
  85.  
  86.  
  87.  
  88. /*
  89.  * The following functions are used to track resources.
  90.  */
  91. struct ToolNode {
  92.     struct ToolNode *Next;
  93.     void *Tool;
  94.     void (*RemProc) (void *, LONG);
  95.     LONG Size;
  96. }
  97.  
  98. *ToolList;
  99.  
  100. void __regargs
  101. RemTool(void *Tool)
  102. {
  103.     struct ToolNode *Ptr, *OPtr;
  104.  
  105.     Ptr = ToolList;
  106.     OPtr = NULL;
  107.     while (Ptr) {
  108.         if (Ptr->Tool==Tool) {
  109.             Ptr->RemProc(Ptr->Tool,Ptr->Size);
  110.             if (OPtr) 
  111.                 OPtr->Next=Ptr->Next;
  112.             else
  113.                 ToolList=Ptr->Next;
  114.             FreeMem(Ptr,sizeof(struct ToolNode));
  115.             return;
  116.         } else {
  117.             OPtr=Ptr;
  118.             Ptr=Ptr->Next;
  119.         }
  120.     }
  121. }
  122.  
  123. void __regargs
  124. Quit(int ReturnCode, char *s)
  125. {
  126.     while (ToolList)
  127.         RemTool(ToolList->Tool);
  128.     if (ReturnCode) Error(s);
  129.     exit(ReturnCode);
  130. }
  131.  
  132. void __regargs
  133. AddTool(void *NewTool, void (*ProcPtr)(void *, LONG), LONG NewSize, char *errmsg)
  134. {
  135.     struct ToolNode *Ptr;
  136.     void (*NewRemProc) (void *, LONG);
  137.  
  138.     NewRemProc = ProcPtr;
  139.     if (NewTool == NULL)
  140.         Quit(10,errmsg);
  141.  
  142.     if ((Ptr = AllocMem(sizeof(struct ToolNode), MEMF_CLEAR)) == NULL) {
  143.         NewRemProc(NewTool, NewSize);
  144.         Quit(20,"Out of Memory.");
  145.     }
  146.     Ptr->Next = ToolList;
  147.     Ptr->Tool = NewTool;
  148.     Ptr->RemProc = NewRemProc;
  149.     Ptr->Size = NewSize;
  150.     ToolList = Ptr;
  151. }
  152.  
  153. /*
  154.  * Some utility functions
  155.  */
  156.  
  157. void __stdargs
  158. DeleteMsgPortSafely(struct MsgPort *AnyPort)
  159. {
  160.     struct Message *AnyMsg;
  161.  
  162.     while (AnyMsg = GetMsg(AnyPort))
  163.         ReplyMsg(AnyMsg);
  164.     DeleteMsgPort(AnyPort);
  165. }
  166.  
  167. int __regargs
  168. ArgIntRange(char **ToolTypes, char *ID, int Min, int Default, int Max)
  169. {
  170.     int Val;
  171.  
  172.     Val = ArgInt(ToolTypes, ID, Default);
  173.     if ((Val < Min) || (Val > Max))
  174.         return Default;
  175.     else
  176.         return Val;
  177. }
  178.  
  179. /*
  180.  * Our "InputHandler".  It signals the server process
  181.  * when an input event is received.
  182.  */
  183.  
  184. void __interrupt __saveds
  185. BlankerAction(CxMsg * CxMsg, CxObj * CO)
  186. {
  187.     struct InputEvent *IE;
  188.  
  189.     IE = (struct InputEvent *)CxMsgData(CxMsg);
  190.     if (IE->ie_Class == IECLASS_TIMER)
  191.         Signal(ServerProcess, 1L << bsp_TimerSig);
  192.     else
  193.         Signal(ServerProcess, 1L << bsp_InputSig);
  194. }
  195.  
  196. /*
  197.  * Returns the value of a gadget in *Data, if the value is between min and max.
  198.  * Otherwise, it sets the gadget to *Data.
  199.  */
  200. LONG
  201. GetNum(struct Window *BlankerWindow, struct Gadget *Gadget, LONG Min, LONG * Data, LONG Max)
  202. {
  203.     LONG NewData;
  204.  
  205.     NewData = ((struct StringInfo *)Gadget->SpecialInfo)->LongInt;
  206.     if ((NewData < Min) || (NewData > Max)) {
  207.         GT_SetGadgetAttrs(Gadget, BlankerWindow, NULL, GTIN_Number, (ULONG) * Data, 
  208.                           TAG_DONE);
  209.         return FALSE;
  210.     } else {
  211.         *Data = NewData;
  212.         return TRUE;
  213.     }
  214. }
  215.  
  216. /*
  217.  * Function to handle the Commodity Stuff
  218.  */
  219.  
  220. void __regargs
  221. HandleCxMsg(CxObj * Broker, CxMsg * CxMsg, LONG * TimeUntilBlank,
  222.             LONG * ThisTimeOut)
  223. {
  224.     ULONG MsgType, MsgID;
  225.  
  226.     MsgType = CxMsgType(CxMsg);
  227.     MsgID = CxMsgID(CxMsg);
  228.     ReplyMsg((struct Message *)CxMsg);
  229.  
  230.     switch (MsgType) {
  231.         case CXM_IEVENT:        /* a hotkey was pressed */
  232.             switch (MsgID) {
  233.                 case HOTKEY_OPEN_WINDOW:
  234.                     OpenBlankerWindow();
  235.                     break;
  236.                 case HOTKEY_BLANK_SCREEN:
  237.                     if (*TimeUntilBlank)
  238.                         *TimeUntilBlank = *ThisTimeOut = 2L;
  239.             }
  240.         case CXM_COMMAND:
  241.             switch (MsgID) {
  242.                 case CXCMD_DISABLE:    /* Message from Exchange
  243.                                          * (except CXCMD_UNIQUE) */
  244.                     (void)ActivateCxObj(Broker, FALSE);
  245.                     break;
  246.                 case CXCMD_ENABLE:
  247.                     (void)ActivateCxObj(Broker, TRUE);
  248.                     break;
  249.                 case CXCMD_UNIQUE:
  250.                 case CXCMD_APPEAR:
  251.                     OpenBlankerWindow();
  252.                     break;
  253.                 case CXCMD_DISAPPEAR:
  254.                     CloseBlankerWindow();
  255.                     break;
  256.                 case CXCMD_KILL:
  257.                     Quit(0,"Normal Termination.");
  258.             }
  259.     }
  260. }
  261.  
  262.  
  263. /*
  264.  * This, annoyingly enough, is neccessary because Retina_CloseScreen is
  265.  * actually a #pragma and not a real function call.  This means you
  266.  * can't pass a pointer to Retina_CloseScreen as a function argument
  267.  * to AddTool.  By adding this wrapper function, we make AddTool work.
  268.  */
  269. void
  270. DestroyScreen(struct RetinaScreen *rs)
  271. {
  272.     Retina_CloseScreen(rs);
  273. }
  274.  
  275. /*
  276.  * Create Screen will first attempt to open a "normal" resolution screen.
  277.  * If that fails, it will try opening a lower resolution screen.
  278.  * If that fails it will return NULL.
  279.  */
  280. struct RetinaScreen *
  281. CreateScreen(UBYTE *colors)
  282. {
  283.     struct RetinaScreen *Screen;
  284.  
  285.     if (!(Screen = Retina_OpenScreen(NORMAL_WIDE, NORMAL_HIGH, MID_DEFAULT_08, NULL,NULL))) 
  286.         if (!(Screen = Retina_OpenScreen(SMALL_WIDE, SMALL_HIGH, MID_DEFAULT_08,NULL, NULL))) 
  287.             return NULL;
  288.     Retina_LoadPalette(Screen, 0, 256, colors);
  289.     SpritesOff(Screen);
  290.     return Screen;
  291. }
  292.  
  293. /*
  294.  * Functions for Creating/Deleting the Client Process
  295.  */
  296.  
  297. void __stdargs
  298. DeleteBlankerClient(struct MsgPort * ClientPort)
  299. {
  300.     struct ClientMessage ClientMessage;
  301.  
  302.     Forbid();
  303.     ClientMessage.bcm_Message.mn_ReplyPort = FINDPROCPORT;
  304.     PutMsg(ClientPort, (struct Message *)&ClientMessage);
  305.  
  306.     (void)SetTaskPri(ClientPort->mp_SigTask, SERVER_PRI);
  307.     Permit();
  308.     
  309.     (void)WaitPort(ClientMessage.bcm_Message.mn_ReplyPort);
  310.     (void)GetMsg(ClientMessage.bcm_Message.mn_ReplyPort);
  311. }
  312.  
  313. struct MsgPort *__regargs
  314. CreateBlankerClient(void *ClientRoutine, struct ClientMessage *ClientMessage)
  315. {
  316.     struct Process *ClientProcess;
  317.     struct TagItem ProcTags[3];
  318.  
  319.     ProcTags[0].ti_Tag = NP_Entry;
  320.     ProcTags[0].ti_Data = (ULONG) ClientRoutine;
  321.     ProcTags[1].ti_Tag = NP_Name;
  322.     ProcTags[1].ti_Data = (ULONG) "BlankerClient";
  323.     ProcTags[2].ti_Tag = TAG_DONE;
  324.  
  325.     if (ClientProcess = CreateNewProc(ProcTags)) {
  326.         ClientMessage->bcm_Message.mn_ReplyPort = FINDPROCPORT;
  327.         PutMsg(&ClientProcess->pr_MsgPort, (struct Message *)ClientMessage);
  328.  
  329.         (void)WaitPort(ClientMessage->bcm_Message.mn_ReplyPort);
  330.         (void)GetMsg(ClientMessage->bcm_Message.mn_ReplyPort);
  331.  
  332.         (void)SetTaskPri((struct Task *)ClientProcess, CLIENT_PRI);
  333.  
  334.         if (ClientMessage->bcm_Status)
  335.             return &ClientProcess->pr_MsgPort;
  336.     }
  337.     return NULL;
  338. }
  339.  
  340. /*
  341.  * A high-speed psuedo random number generator.
  342.  */
  343. WORD __regargs
  344. Random(WORD Max)
  345. {
  346.     static ULONG Num = 0L;
  347.     ULONG Sec, Mic;
  348.  
  349.     CurrentTime((ULONG *) & Sec, (ULONG *) & Mic);
  350.  
  351.     Num *= Sec;
  352.     Num += Mic;
  353.  
  354.     while (Num > 32767L)
  355.         Num = Num >> 1;
  356.  
  357.     return (WORD)(Num % Max);
  358. }
  359.  
  360. /*
  361.  * This is the Client Process's Main Loop
  362.  */
  363. void __interrupt __saveds
  364. RLinesClientProcess(void)
  365. {
  366.     struct ClientMessage *ClientMessage;
  367.     struct MsgPort *ClientPort;
  368.     struct Task *ServerTask;
  369.     ULONG ServerSigMask;
  370.     struct RetinaScreen *LinesScreen;
  371.     LONG NumLines, Speed;
  372.     void *plist;
  373.  
  374.     /* wait for Server's initial Message */
  375.  
  376.     ClientPort = FINDPROCPORT;
  377.     (void)WaitPort(ClientPort);
  378.     ClientMessage = (struct ClientMessage *)GetMsg(ClientPort);
  379.  
  380.     ServerTask = ClientMessage->bcm_Message.mn_ReplyPort->mp_SigTask;
  381.     ServerSigMask = ClientMessage->bcm_SigMask;
  382.  
  383.     NumLines = ClientMessage->bcm_Lines;
  384.     Speed = ClientMessage->bcm_Speed;
  385.     LinesScreen = ClientMessage->bcm_Screen;
  386.  
  387.     if (LinesScreen) {
  388.         if ((plist = CreateLines(LinesScreen, NumLines, Speed))== NULL) {
  389.             ClientMessage->bcm_Status = FALSE;
  390.             Forbid();
  391.             ReplyMsg((struct Message *)ClientMessage);
  392.             return;
  393.         }
  394.     }
  395.             
  396.     ClientMessage->bcm_Status = TRUE;
  397.     ReplyMsg((struct Message *)ClientMessage);
  398.  
  399.     while ((ClientMessage =
  400.       (struct ClientMessage *)GetMsg(ClientPort)) == NULL) {
  401.         if (LinesScreen) {
  402.             DrawLines(plist, LinesScreen);
  403.         }
  404.         Signal(ServerTask, ServerSigMask);
  405.     }
  406.  
  407.     /* We are requested to finish, so we do. */
  408.     Forbid();
  409.     ReplyMsg((struct Message *)ClientMessage);
  410. }
  411.  
  412.